{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# REINFORCE Policy Optimization with PyTorch\n",
    "\n",
    "In this notebook, we will look at policy optimization using PyTorch. Let us quickly go through the derivation of what is policy Optimization and then we will apply this to CartPole environment - just like what we did in Chapters 6 & 7. \n",
    "\n",
    "\n",
    "### Derivation of Policy Gradient\n",
    "In Policy Optimization, we will have a neural network which takes in state `s` as input and produces the `logits` for action probabilities. \n",
    "\n",
    "The policy is parameterized by $\\theta$\n",
    "$$\\pi_\\theta(a|s)$$\n",
    "\n",
    "The agent follows the policy and generates the trajectory $\\large \\tau$ \n",
    "\n",
    "$$ s_1 \\rightarrow a_1 \\rightarrow s_2 \\rightarrow a_2 \\rightarrow .... \\rightarrow s_{T-1} \\rightarrow a_{T-1} \\rightarrow s_T \\rightarrow a_T$$ \n",
    "\n",
    "here $s_T$ is not necessarily the terminal state but some time horizon T upto which we are looking at the trajectory. \n",
    "\n",
    "The probability of trajectory $\\large \\tau$ depends on the transition probabilities $p(s_t+1 | s_t, a_t)$ and the policy $\\pi_\\theta(a_t|s_t)$. It is given by the expression:\n",
    "\n",
    "$$p_\\theta(\\tau) = p_\\theta(s_1, a_1, s_2, a_2, ..., s_T, a_T) = p(s_1)\\prod_{t=1}^{T}\\pi_\\theta(a_t|s_t)p(s_{t+1}|s_t,a_t)$$\n",
    "\n",
    "The expected return from following the policy $\\pi$ is given by:\n",
    "\n",
    "$$J(\\theta) = {\\large E}_{\\tau \\sim p_\\theta(\\tau)} \\left[ \\sum_{t} \\gamma^t r(s_t, a_t) \\right]$$\n",
    "\n",
    "We want to find the $\\theta$ which maximizes the expected reward/return $J(\\theta)$. In other words, the optimal $\\theta=\\theta^*$ is given by expression\n",
    "\n",
    "$$\\theta^* = arg \\underset{\\theta}{max}{\\large E}_{\\tau \\sim p_\\theta(\\tau)} \\left[ \\sum_{t} \\gamma^t r(s_t, a_t) \\right] $$\n",
    "\n",
    "Moving on, let us try to find the optimal $\\theta$. To keep the notations easier to understand, we will replace $\\sum_{t} \\gamma^t r(s_t, a_t)$ as $r(\\tau)$:\n",
    "\n",
    "$$J(\\theta) = {\\large E}_{\\tau \\sim p_\\theta(\\tau)} \\left[ r(\\tau) \\right] = \\int p_\\theta(\\tau)r(\\tau) d\\tau$$\n",
    "\n",
    "We take the gradient/derivative of above expression with respect to $\\theta$:\n",
    "\n",
    "$$\\nabla_{\\theta} J(\\theta) =  \\nabla_{\\theta} \\int p_\\theta(\\tau)r(\\tau) d\\tau $$\n",
    "\n",
    "By linearity we can move the gradient inside the integral:\n",
    "\n",
    "$$\\nabla_{\\theta} J(\\theta) =  \\int \\nabla_{\\theta} p_\\theta(\\tau)r(\\tau) d\\tau $$\n",
    "\n",
    "Using log derivative trick, we know that $\\nabla_x f(x) = f(x) \\nabla_x \\log{f(x)}$. Using this we can write above expression as:\n",
    "\n",
    "$$\\nabla_{\\theta} J(\\theta) =  \\int p_\\theta(\\tau) \\left[ \\nabla_{\\theta}\\log{p_\\theta(\\tau)} r(\\tau) \\right] d\\tau $$\n",
    "\n",
    "We can now write the integral back as expectation, which gives us the expression:\n",
    "\n",
    "$$\\nabla_{\\theta} J(\\theta) =  {\\large E}_{\\tau \\sim p_\\theta(\\tau)} \\left[ \\nabla_{\\theta}\\log{p_\\theta(\\tau)} r(\\tau) \\right] $$\n",
    "\n",
    "Let us now expand the term $\\nabla_{\\theta}\\log{p_\\theta(\\tau)}$ by writing out the full expression of $p_\\theta(\\tau)$. \n",
    "\n",
    "$$ \\nabla_{\\theta}\\log{p_\\theta(\\tau)}  = \\nabla_{\\theta} \\log{ \\left[ p(s_1) \\prod_{t=1}^{T}\\pi_\\theta(a_t|s_t)p(s_{t+1}|s_t,a_t)\\right]}$$\n",
    "\n",
    "We know that log of product of terms can be written as sum of log of terms i.e. \n",
    "\n",
    "$$\\log{\\prod_i f_i(x)} = \\sum_i log{f_i(x)}$$ \n",
    "\n",
    "Using the above substitution, we get:\n",
    "\n",
    "$$ \\nabla_{\\theta}\\log{p_\\theta(\\tau)}  = \\nabla_{\\theta} \\left[ log{p(s_1)} +  \\sum_{t=1}^{T} \\left\\{ \\log{ \\pi_\\theta(a_t|s_t)} + \\log{p(s_{t+1}|s_t,a_t)} \\right\\} \\right]$$\n",
    "\n",
    "The only term dependent on $\\theta$ is $\\pi_\\theta(a_t|s_t)$. The other two terms $log{p(s_1)}$ and $\\log{p(s_{t+1}|s_t,a_t)}$ do not depend on $\\theta$. Accordingly, we can simplify the above expression as:\n",
    "\n",
    "$$ \\nabla_{\\theta}\\log{p_\\theta(\\tau)}  = \\sum_{t=1}^{T} \\nabla_{\\theta} \\log{ \\pi_\\theta(a_t|s_t)} $$\n",
    "\n",
    "\n",
    "Substituting the above term into the expression for $\\nabla_{\\theta} J(\\theta)$, as well as expanding $r(\\tau)$ we get:\n",
    "\n",
    "$$\\nabla_{\\theta} J(\\theta) =  {\\large E}_{\\tau \\sim p_\\theta(\\tau)} \\left[ \\left( \\sum_{t=1}^{T} \\nabla_{\\theta} \\log{ \\pi_\\theta(a_t|s_t)} \\right) \\left( \\sum_{t=1}^{T} \\gamma^t r(s_t, a_t) \\right) \\right] $$\n",
    "\n",
    "We can now replace the outer expectation with an estimate over multiple trajectories to get the following expression for the gradient of policy objective:\n",
    "\n",
    "$$\\nabla_{\\theta} J(\\theta) =  \\frac{1}{N} \\sum_{i=1}^{N} \\left[ \\left( \\sum_{t=1}^{T} \\nabla_{\\theta} \\log{ \\pi_\\theta(a_t^i|s_t^i)} \\right) \\left( \\sum_{t=1}^{T} \\gamma^t r(s_t^i, a_t^i) \\right) \\right] $$\n",
    "\n",
    "where i denotes the $i^{th}$ trajectory. \n",
    "\n",
    "To improve the policy, we now take a +ve step in $\\theta$ in the direction of $\\nabla_{\\theta} J(\\theta)$:\n",
    "\n",
    "$$\\theta = \\theta + \\alpha \\nabla_{\\theta} J(\\theta)$$\n",
    "\n",
    "To summarize, we design a model which takes state $s$ as input and produces the policy distribution $\\pi_\\theta(a|s)$ as the output of the model. We use a policy to generate returns and then change the model parameter $\\theta$ using the expression: $\\theta = \\theta + \\alpha \\nabla_{\\theta} J(\\theta)$\n",
    "\n",
    "\n",
    "### Rewards to Go Trick\n",
    "\n",
    "\n",
    "we drop the reward terms that came before time t as at time t, the action we take can only impact the reward which comes at time t and later. This leads to changing the 2nd inner sum going from t’=t to T instead of earlier sum over t’ going from t’=1 to T. i.e. the start index is now t’=t and not t=1. The revised expression is given below:\n",
    "\n",
    "\n",
    "$$\\nabla_{\\theta} J(\\theta) =  \\frac{1}{N} \\sum_{i=1}^{N} \\left[  \\sum_{t=1}^{T}  \\left( \\nabla_{\\theta} \\log{ \\pi_\\theta(a_t^i|s_t^i)} \\sum_{t'=t}^{T} \\gamma^{t'-t} r(s_{t'}^i, a_{t'}^i) \\right) \\right] $$\n",
    "\n",
    "\n",
    "### Implementing Loss and Gradient Step in PyTorch\n",
    "\n",
    "We will implement a pseudo loss function, whose derivative will give us $\\nabla_{\\theta} J(\\theta)$. Also as PyTorch/TensorFlow carryout a gradient Step, we will convert maximization to minimization by changing the sign of this objective function\n",
    "\n",
    "$$L_{\\text{Cross-entropy}}(\\theta) = - J(\\theta) = - \\frac{1}{N} \\sum_{i=1}^{N} \\left[ \\sum_{t=1}^{T} \\left(  \\log{ \\pi_\\theta(a_t^i|s_t^i)} \\sum_{t'=t}^{T} \\gamma^{t'-t} r(s_{t'}^i, a_{t'}^i) \\right) \\right] $$\n",
    "\n",
    "To summarize, we will pass the state `s` through the network to get $\\log{ \\pi_\\theta(a_t^i|s_t^i)}$. We will calculate the cross_entropy loss for the actions actually seen in the trajectory. We will then calculate the weighted mean of these individual loss terms in the trajectory with weights being the rewards-to-go $\\sum_{t'=t}^{T} \\gamma^{t'-t} r(s_{t'}^i, a_{t'}^i)$\n",
    "\n",
    "This will be followed by a gradient step in -ve direction of weighted NLL (negative log loss) i.e. in positive direction of the gradient of $J(\\theta)= - L_{\\text{Cross-entropy}}(\\theta)$ \n",
    "\n",
    "We also add a regularization term known as Entropy. Entropy of a distribution is defined as:\n",
    "\n",
    "$$H(X) = \\sum_x -p(x).log(p(x))$$\n",
    "\n",
    "To keep enough exploration, we will want the probability to have a spread out distribution and not let the probability distribution collapse to a single value or a small region too soon. Bigger the spread of a distribution, higher the entropy H(x) of a distribution. Accordingly, the term fed into PyTorch/TensorFlow minimizer is:\n",
    "\n",
    "\n",
    "$$Loss(\\theta) = - J(\\theta) - H(\\pi_\\theta(a_t^i|s_t^i)) = - \\frac{1}{N} \\sum_{i=1}^{N} \\left[ \\sum_{t=1}^{T} \\left(  \\log{ \\pi_\\theta(a_t^i|s_t^i)} \\sum_{t'=t}^{T} \\gamma^{t'-t} r(s_{t'}^i, a_{t'}^i) \\right) - \\beta \\sum_{a_i} \\pi_\\theta(a_t^i|s_t^i).\\log{ \\pi_\\theta(a_t^i|s_t^i)} \\right] $$\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Running in Colab/Kaggle\n",
    "\n",
    "If you are running this on Colab, please uncomment below cells and run this to install required dependencies."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "## Uncomment and execute this cell to install all the the dependencies if running in Google Colab\n",
    "\n",
    "# !apt-get update && apt-get install swig cmake ffmpeg freeglut3-dev xvfb\n",
    "# !pip install box2d-py\n",
    "# !pip install \"stable-baselines3[extra]>=2.1\"\n",
    "# !pip install \"huggingface_sb3>=3.0\"\n",
    "\n",
    "# !pip install git+https://github.com/DLR-RM/rl-baselines3-zoo@update/hf\n",
    "# !git clone https://github.com/DLR-RM/rl-baselines3-zoo\n",
    "# %cd rl-baselines3-zoo/\n",
    "# !pip install -r requirements.txt\n",
    "# %cd ..\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Imports"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "2024-01-10 17:26:04.636985: I tensorflow/core/util/port.cc:111] oneDNN custom operations are on. You may see slightly different numerical results due to floating-point round-off errors from different computation orders. To turn them off, set the environment variable `TF_ENABLE_ONEDNN_OPTS=0`.\n",
      "2024-01-10 17:26:04.639725: I tensorflow/tsl/cuda/cudart_stub.cc:28] Could not find cuda drivers on your machine, GPU will not be used.\n",
      "2024-01-10 17:26:04.706592: E tensorflow/compiler/xla/stream_executor/cuda/cuda_dnn.cc:9342] Unable to register cuDNN factory: Attempting to register factory for plugin cuDNN when one has already been registered\n",
      "2024-01-10 17:26:04.706640: E tensorflow/compiler/xla/stream_executor/cuda/cuda_fft.cc:609] Unable to register cuFFT factory: Attempting to register factory for plugin cuFFT when one has already been registered\n",
      "2024-01-10 17:26:04.706661: E tensorflow/compiler/xla/stream_executor/cuda/cuda_blas.cc:1518] Unable to register cuBLAS factory: Attempting to register factory for plugin cuBLAS when one has already been registered\n",
      "2024-01-10 17:26:04.713850: I tensorflow/tsl/cuda/cudart_stub.cc:28] Could not find cuda drivers on your machine, GPU will not be used.\n",
      "2024-01-10 17:26:04.715404: I tensorflow/core/platform/cpu_feature_guard.cc:182] This TensorFlow binary is optimized to use available CPU instructions in performance-critical operations.\n",
      "To enable the following instructions: AVX2 AVX_VNNI FMA, in other operations, rebuild TensorFlow with the appropriate compiler flags.\n",
      "2024-01-10 17:26:05.647501: W tensorflow/compiler/tf2tensorrt/utils/py_utils.cc:38] TF-TRT Warning: Could not find TensorRT\n"
     ]
    }
   ],
   "source": [
    "import random\n",
    "import numpy as np\n",
    "import torch\n",
    "import torch.nn as nn\n",
    "import gymnasium as gym\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "from scipy.signal import convolve, gaussian\n",
    "from stable_baselines3.common.vec_env import VecVideoRecorder, DummyVecEnv\n",
    "\n",
    "from IPython.display import HTML, clear_output\n",
    "from base64 import b64encode\n",
    "\n",
    "%matplotlib inline"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Environment - CartPole \n",
    "\n",
    "We can use the setup here to run on any environment which has state as a single vector and actions are discrete. We will build it on Cart Pole and they try to run this on many other environments like Atari games and others."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "def make_env(env_name):\n",
    "    env = gym.make(env_name, render_mode=\"rgb_array\")\n",
    "    return env"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "state shape:(4,)\n",
      "Number of Actions:2\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "env_name = 'CartPole-v1'\n",
    "seed=123\n",
    "\n",
    "env = make_env(env_name)\n",
    "env.reset(seed=seed)\n",
    "plt.imshow(env.render())\n",
    "state_shape, n_actions = env.observation_space.shape, env.action_space.n\n",
    "state_dim = state_shape[0]\n",
    "print(f\"state shape:{state_shape}\\nNumber of Actions:{n_actions}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Build Policy Network\n",
    "\n",
    "We will build a simple network that takes in state and produces logits for the action probabilities. We will keep network simple. he observation space and action space is as given below for CartPole\n",
    "\n",
    "    Observation:\n",
    "        Type: Box(4)\n",
    "        Num     Observation               Min                     Max\n",
    "        0       Cart Position             -4.8                    4.8\n",
    "        1       Cart Velocity             -Inf                    Inf\n",
    "        2       Pole Angle                -0.418 rad (-24 deg)    0.418 rad (24 deg)\n",
    "        3       Pole Angular Velocity     -Inf                    Inf\n",
    "    Actions:\n",
    "        Type: Discrete(2)\n",
    "        Num   Action\n",
    "        0     Push cart to the left\n",
    "        1     Push cart to the right\n",
    "        \n",
    "\n",
    "The model will be a simple one with 1 hidden layer with Relu activation and final layer being logits with dimension equal to number of actions."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "device(type='cpu')"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')\n",
    "device"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "model = nn.Sequential(\n",
    "            nn.Linear(state_dim,192),\n",
    "            nn.ReLU(),\n",
    "            nn.Linear(192,n_actions),\n",
    ")\n",
    "model = model.to(device)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Predict Action Probabilities\n",
    "\n",
    "We will use this function to generate the trajectory. It will not be used for doing back propagation. So we will use PyTorch `no_grad()` to avoid gradient calculations. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "def predict_probs(states):\n",
    "    \"\"\"\n",
    "    params: states: [batch, state_dim]\n",
    "    returns: probs: [batch, n_actions]\n",
    "    \"\"\"\n",
    "    states = torch.tensor(np.array(states), device=device, dtype=torch.float32)\n",
    "    with torch.no_grad():\n",
    "        logits = model(states)\n",
    "    probs = nn.functional.softmax(logits, -1).detach().cpu().numpy()\n",
    "    return probs"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Play game and generate Trajectory"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "def generate_trajectory(env, n_steps=1000):\n",
    "    \"\"\"\n",
    "    Play a session and generate a trajectory\n",
    "    returns: arrays of states, actions, rewards\n",
    "    \"\"\"\n",
    "    states, actions, rewards = [], [], []\n",
    "\n",
    "    # initialize the environment\n",
    "    s, _ = env.reset()    \n",
    "    \n",
    "    #generate n_steps of trajectory:\n",
    "    for t in range(n_steps):\n",
    "        action_probs = predict_probs(np.array([s]))[0]\n",
    "        #sample action based on action_probs\n",
    "        a = np.random.choice(n_actions, p=action_probs)\n",
    "        next_state, r, done, _, _ = env.step(a)\n",
    "        \n",
    "        #update arrays\n",
    "        states.append(s)\n",
    "        actions.append(a)\n",
    "        rewards.append(r)\n",
    "        \n",
    "        s = next_state\n",
    "        if done:\n",
    "            break\n",
    "    \n",
    "    return np.array(states), np.array(actions), np.array(rewards)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Evaluation of Agent"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "def evaluate(env, agent, n_games=3, t_max=10000):\n",
    "    rewards = []\n",
    "    for i in range(n_games):\n",
    "        s,_ = env.reset(seed=seed+i)\n",
    "        reward = 0\n",
    "        for _ in range(t_max):\n",
    "            action_probs = predict_probs(np.array([s]))[0]\n",
    "            #sample action based on action_probs\n",
    "            a = np.random.choice(n_actions, p=action_probs)\n",
    "            next_state, r, terminated, _, _ = env.step(a)\n",
    "            reward += r\n",
    "            s = next_state\n",
    "            if terminated:\n",
    "                break\n",
    "\n",
    "        rewards.append(reward)\n",
    "    return np.mean(rewards)\n",
    "\n",
    "def smoothen(values):\n",
    "    kernel = gaussian(100, std=100)\n",
    "    kernel = kernel / np.sum(kernel)\n",
    "    return convolve(values, kernel, 'valid')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Calculate Rewards to Go\n",
    "\n",
    " $G(s_t) = \\sum_{t'=t}^{T} \\gamma^{t-t'} r(s_{t'}^i, a_{t'}^i)$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_rewards_to_go(rewards, gamma=0.99):\n",
    "    \n",
    "    T = len(rewards) # total number of individual rewards\n",
    "    # empty array to return the rewards to go\n",
    "    rewards_to_go = [0]*T \n",
    "    rewards_to_go[T-1] = rewards[T-1]\n",
    "    \n",
    "    for i in range(T-2, -1, -1): #go from T-2 to 0\n",
    "        rewards_to_go[i] = gamma * rewards_to_go[i+1] + rewards[i]\n",
    "    \n",
    "    return rewards_to_go"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Train on one trajectory\n",
    "\n",
    "We will calculate the loss and take a gradient step. We will use Adam Optimizer\n",
    "\n",
    "We are taking only one trajectory. so N=1. We will however, average it over the number of actions to get the average loss. So the function we will actually implement is as given below:\n",
    "\n",
    "$$Loss(\\theta) = - J(\\theta) - H(\\pi_\\theta(a_t|s_t)) = - \\frac{1}{T}  \\sum_{t=1}^{T} \\left( \\log{ \\pi_\\theta(a_t|s_t)} G(s_t) - \\beta \\sum_{a_i} \\pi_\\theta(a_t|s_t).\\log{ \\pi_\\theta(a_t|s_t)} \\right) $$\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "#init Optimizer\n",
    "optimizer = torch.optim.Adam(model.parameters(), lr=1e-3)\n",
    "\n",
    "def train_one_episode(states, actions, rewards, gamma=0.99, entropy_coef=1e-2):\n",
    "    \n",
    "    \n",
    "    # get rewards to go\n",
    "    rewards_to_go = get_rewards_to_go(rewards, gamma)\n",
    "\n",
    "    # convert numpy array to torch tensors\n",
    "    states = torch.tensor(states, device=device, dtype=torch.float)\n",
    "    actions = torch.tensor(actions, device=device, dtype=torch.long)\n",
    "    rewards_to_go = torch.tensor(rewards_to_go, device=device, dtype=torch.float)\n",
    "\n",
    "    # get action probabilities from states\n",
    "    logits = model(states)\n",
    "    probs = nn.functional.softmax(logits, -1)\n",
    "    log_probs = nn.functional.log_softmax(logits, -1)\n",
    "    \n",
    "    log_probs_for_actions = log_probs[range(len(actions)), actions]\n",
    "    \n",
    "    #Compute loss to be minimized\n",
    "    J = torch.mean(log_probs_for_actions*rewards_to_go)\n",
    "    H = -(probs*log_probs).sum(-1).mean()\n",
    "    \n",
    "    loss = -(J+entropy_coef*H)\n",
    "\n",
    "    optimizer.zero_grad()\n",
    "    loss.backward()\n",
    "    optimizer.step()\n",
    "    \n",
    "    return loss.detach().cpu() #to show progress on training\n",
    "    "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Train the agent"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "eval_freq = 10\n",
    "n_episodes = 1000"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1600x500 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "loss_history = []\n",
    "return_history = []\n",
    "\n",
    "for i in range(5000):\n",
    "    states, actions, rewards = generate_trajectory(env)\n",
    "    loss = train_one_episode(states, actions, rewards)\n",
    "    # return_history.append(np.sum(rewards))\n",
    "    loss_history.append(loss)\n",
    "\n",
    "    if i != 0 and i % eval_freq == 0:\n",
    "        mean_return = np.mean(return_history[-eval_freq:])\n",
    "        if mean_return > 500:\n",
    "            break\n",
    "\n",
    "    if i != 0 and i % eval_freq == 0:\n",
    "        # eval the agent\n",
    "        eval_env = make_env(env_name)\n",
    "        return_history.append(\n",
    "            evaluate(eval_env, model)\n",
    "        )\n",
    "        eval_env.close()\n",
    "        clear_output(True)\n",
    "\n",
    "        plt.figure(figsize=[16, 5])\n",
    "        plt.subplot(1, 2, 1)\n",
    "        plt.title(\"Mean return per episode\")\n",
    "        plt.plot(return_history)\n",
    "        plt.grid()\n",
    "\n",
    "        assert not np.isnan(loss_history[-1])\n",
    "        plt.subplot(1, 2, 2)\n",
    "        plt.title(\"Loss history (smoothened)\")\n",
    "        plt.plot(smoothen(loss_history))\n",
    "        plt.grid()\n",
    "\n",
    "        plt.show()\n",
    "\n",
    "\n",
    "env.close()\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Let us record a video of trained agent**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Helper function to record videos\n",
    "def record_video(env_id, video_folder, video_length, agent):\n",
    "\n",
    "    vec_env = DummyVecEnv([lambda: gym.make(env_id, render_mode=\"rgb_array\")])\n",
    "    # Record the video starting at the first step\n",
    "    vec_env = VecVideoRecorder(vec_env, video_folder,\n",
    "                           record_video_trigger=lambda x: x == 0, video_length=video_length,\n",
    "                           name_prefix=f\"{type(agent).__name__}-{env_id}\")\n",
    "\n",
    "    obs = vec_env.reset()\n",
    "    for _ in range(video_length + 1):\n",
    "        policy_prob = predict_probs(obs)\n",
    "        action_probs = policy_prob[0]\n",
    "        action = [np.random.choice(n_actions, p=action_probs)]\n",
    "        obs, _, _, _ = vec_env.step(action)\n",
    "    # video filename\n",
    "    file_path = \"./\"+video_folder+vec_env.video_recorder.path.split(\"/\")[-1]\n",
    "    # Save the video\n",
    "    vec_env.close()\n",
    "    return file_path\n",
    "\n",
    "def play_video(file_path):\n",
    "    mp4 = open(file_path, 'rb').read()\n",
    "    data_url = \"data:video/mp4;base64,\" + b64encode(mp4).decode()\n",
    "    return HTML(\"\"\"\n",
    "        <video width=400 controls>\n",
    "              <source src=\"%s\" type=\"video/mp4\">\n",
    "        </video>\n",
    "        \"\"\" % data_url)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Saving video to /home/nsanghi/sandbox/apress/drl-2ed/chapter8/logs/8_a/Sequential-CartPole-v1-step-0-to-step-500.mp4\n",
      "Moviepy - Building video /home/nsanghi/sandbox/apress/drl-2ed/chapter8/logs/8_a/Sequential-CartPole-v1-step-0-to-step-500.mp4.\n",
      "Moviepy - Writing video /home/nsanghi/sandbox/apress/drl-2ed/chapter8/logs/8_a/Sequential-CartPole-v1-step-0-to-step-500.mp4\n",
      "\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "                                                                                                                        \r"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Moviepy - Done !\n",
      "Moviepy - video ready /home/nsanghi/sandbox/apress/drl-2ed/chapter8/logs/8_a/Sequential-CartPole-v1-step-0-to-step-500.mp4\n"
     ]
    },
    {
     "data": {
      "text/html": [
       "\n",
       "        <video width=400 controls>\n",
       "              <source src=\"data:video/mp4;base64,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\" type=\"video/mp4\">\n",
       "        </video>\n",
       "        "
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "video_folder = \"logs/8_a/\"\n",
    "video_length = 500\n",
    "\n",
    "video_file = record_video(env_name, video_folder, video_length, model)\n",
    "\n",
    "play_video(video_file)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Conclusion\n",
    "In this notebook we saw how REINFORCE with rewards-to-go is implemented. We also saw that learning has been very choppy. The return per episode fluctuates a lot and does not look very stable. In the next book we look at more efficient versions of policy learning approaches"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.9.18"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}
